/**
 * 通用事件分发系统 (EventDispatcher)
 * 
 * 功能说明：
 * - 提供基于类型的事件注册、分发和移除机制
 * - 支持事件参数类型安全
 * - 支持批量注册、移除和自动清理
 * - 便于模块间解耦通信
 * 
 * 设计模式：
 * - 观察者模式 (Observer Pattern)
 * - 委托与事件 (Delegate & Event)
 * - 资源管理 (IDisposable)
 * 
 * 使用场景：
 * - 游戏模块间消息通信
 * - UI与逻辑解耦
 * - 业务事件驱动
 * - 资源加载、网络、输入等事件
 */

using System;
using System.Collections.Generic;

/**
 * 事件参数基类
 * 
 * 所有事件参数都应继承自EventArgs，便于类型安全和扩展
 */
public abstract class EventArgs
{
    public object Sender { get; set; }      // 事件发送者
    public DateTime Timestamp { get; set; } // 事件触发时间

    protected EventArgs(object sender = null)
    {
        Sender = sender;
        Timestamp = DateTime.Now;
    }
}

/**
 * 事件监听器管理类
 * 
 * 用于批量注册、移除和自动清理事件监听器
 * 支持IDisposable接口，便于自动释放
 */
public class EventListenerManager : IDisposable
{
    private readonly EventDispatcher _dispatcher;
    private readonly Dictionary<Type, List<Delegate>> _registeredHandlers = new Dictionary<Type, List<Delegate>>();

    public EventListenerManager(EventDispatcher dispatcher)
    {
        _dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
    }

    /**
     * 注册单个事件监听器
     * 
     * 参数：
     * - handler: 事件处理委托
     */
    public void RegisterEvent<T>(Action<T> handler) where T : EventArgs
    {
        var eventType = typeof(T);
        
        if (!_registeredHandlers.ContainsKey(eventType))
        {
            _registeredHandlers[eventType] = new List<Delegate>();
        }
        
        _registeredHandlers[eventType].Add(handler);
        _dispatcher.RegisterEvent(handler);
    }

    /**
     * 批量注册事件监听器
     * 
     * 参数：
     * - events: (事件类型, 事件处理委托)元组数组
     */
    public void RegisterEvents(params (Type eventType, Delegate handler)[] events)
    {
        foreach (var (eventType, handler) in events)
        {
            if (!_registeredHandlers.ContainsKey(eventType))
            {
                _registeredHandlers[eventType] = new List<Delegate>();
            }
            
            _registeredHandlers[eventType].Add(handler);
            
            // 使用反射调用泛型方法
            var registerMethod = typeof(EventDispatcher).GetMethod("RegisterEvent").MakeGenericMethod(eventType);
            registerMethod.Invoke(_dispatcher, new object[] { handler });
        }
    }

    /**
     * 移除特定事件监听器
     */
    public void UnregisterEvent<T>(Action<T> handler) where T : EventArgs
    {
        var eventType = typeof(T);
        
        if (_registeredHandlers.ContainsKey(eventType))
        {
            _registeredHandlers[eventType].Remove(handler);
            _dispatcher.RemoveEvent(handler);
        }
    }

    /**
     * 移除所有事件监听器
     */
    public void UnregisterAllEvents()
    {
        foreach (var kvp in _registeredHandlers)
        {
            var eventType = kvp.Key;
            var handlers = kvp.Value;
            
            foreach (var handler in handlers)
            {
                var removeMethod = typeof(EventDispatcher).GetMethod("RemoveEvent").MakeGenericMethod(eventType);
                removeMethod.Invoke(_dispatcher, new object[] { handler });
            }
        }
        
        _registeredHandlers.Clear();
    }

    /**
     * 获取已注册的事件类型
     */
    public IEnumerable<Type> GetRegisteredEventTypes()
    {
        return _registeredHandlers.Keys;
    }

    /**
     * 获取特定事件类型的处理器数量
     */
    public int GetHandlerCount<T>() where T : EventArgs
    {
        var eventType = typeof(T);
        return _registeredHandlers.ContainsKey(eventType) ? _registeredHandlers[eventType].Count : 0;
    }

    /**
     * 实现IDisposable接口，自动清理
     */
    public void Dispose()
    {
        UnregisterAllEvents();
    }
}

/**
 * 事件分发器
 * 
 * 提供基于类型的事件注册、分发、移除和查询功能
 * 支持泛型事件参数，类型安全
 */
public class EventDispatcher
{
    // 使用类型作为key的事件字典
    private Dictionary<Type, object> _eventMap = new Dictionary<Type, object>();

    /**
     * 注册事件监听器
     * 
     * 参数：
     * - action: 事件处理委托
     * 返回：注册的委托（便于链式调用）
     */
    public Action<T> RegisterEvent<T>(Action<T> action) where T : EventArgs
    {
        var eventType = typeof(T);
        
        if (!_eventMap.ContainsKey(eventType))
        {
            _eventMap[eventType] = new List<Action<T>>();
        }
        
        var handlers = (List<Action<T>>)_eventMap[eventType];
        handlers.Add(action);
        
        return action;
    }

    /**
     * 移除事件监听器
     * 
     * 参数：
     * - action: 要移除的事件处理委托
     */
    public void RemoveEvent<T>(Action<T> action) where T : EventArgs
    {
        var eventType = typeof(T);
        
        if (_eventMap.ContainsKey(eventType))
        {
            var handlers = (List<Action<T>>)_eventMap[eventType];
            handlers.Remove(action);
            
            // 如果没有处理器了，移除整个事件
            if (handlers.Count == 0)
            {
                _eventMap.Remove(eventType);
            }
        }
    }

    /**
     * 分发事件
     * 
     * 参数：
     * - args: 事件参数，必须继承自EventArgs
     * 
     * 功能：
     * - 触发所有注册的事件处理器
     */
    public void DispatchEvent<T>(T args) where T : EventArgs
    {
        var eventType = typeof(T);
        
        if (_eventMap.ContainsKey(eventType))
        {
            var handlers = (List<Action<T>>)_eventMap[eventType];
            foreach (var handler in handlers)
            {
                handler?.Invoke(args);
            }
        }
    }

    /**
     * 检查事件是否存在
     * 
     * 返回：是否存在指定类型的事件处理器
     */
    public bool HasEvent<T>() where T : EventArgs
    {
        var eventType = typeof(T);
        return _eventMap.ContainsKey(eventType) && 
               _eventMap[eventType] is List<Action<T>> handlers && 
               handlers.Count > 0;
    }

    /**
     * 获取事件处理器数量
     */
    public int GetEventCount<T>() where T : EventArgs
    {
        var eventType = typeof(T);
        if (_eventMap.ContainsKey(eventType) && _eventMap[eventType] is List<Action<T>> handlers)
        {
            return handlers.Count;
        }
        return 0;
    }

    /**
     * 清空所有事件
     */
    public void Clear()
    {
        _eventMap.Clear();
    }

    /**
     * 清空特定事件
     */
    public void ClearEvent<T>() where T : EventArgs
    {
        var eventType = typeof(T);
        if (_eventMap.ContainsKey(eventType))
        {
            _eventMap.Remove(eventType);
        }
    }

    // 获取所有已注册的事件类型
    public IEnumerable<Type> GetRegisteredEventTypes()
    {
        return _eventMap.Keys;
    }

    // 创建事件监听器管理器
    public EventListenerManager CreateListenerManager()
    {
        return new EventListenerManager(this);
    }
}